òɾۿûѧϰʹá
ԭַhttps://www.joinquant.com/post/13976

ԭһ˵ʽ鵽ԭĺ߽ۡ


ԭĲԴ£

from kuanke.wizard import *
from jqdata import *
import numpy as np
import pandas as pd
import talib
import datetime

## ʼ趨ҪĹƱ׼ȵ
def initialize(context):
    # 趨׼
    set_benchmark('000300.XSHG')
    # 趨
    set_slippage(FixedSlippage(0.02))
    # TrueΪ̬Ȩģʽʹʵ۸
    set_option('use_real_price', True)
    # 趨ɽ
    set_option('order_volume_ratio', 1)
    # ƱཻǣʱӶ֮ʱӶ֮ǧ֮һӡ˰, ÿʽӶͿ5Ǯ
    set_order_cost(OrderCost(open_tax=0, close_tax=0.001, open_commission=0.0003, close_commission=0.0003, min_commission=5), type='stock')
    # ֱֲ
    g.security_max_proportion = 1
    # ѡƵ
    g.check_stocks_refresh_rate = 1
    # Ƶ
    g.buy_refresh_rate = 1
    # Ƶ
    g.sell_refresh_rate = 1
    # 󽨲
    g.max_hold_stocknum = 5

    # ѡƵʼ
    g.check_stocks_days = 0
    # Ƶʼ
    g.buy_trade_days=0
    g.sell_trade_days=0
    # ȡδĹƱ
    g.open_sell_securities = []
    # Ʊdict
    g.selled_security_list={}

    # Ʊɸѡʼ
    check_stocks_initialize()
    # Ʊɸѡʼ
    check_stocks_sort_initialize()
    # ʼ
    sell_initialize()
    # 볡ʼ
    buy_initialize()
    # سʼ
    risk_management_initialize()

    # رʾ
    log.set_level('order', 'info')

    # к
    run_daily(sell_every_day,'open') #δɹĹƱ
    run_daily(risk_management, 'every_bar') #տ
    run_daily(check_stocks, 'open') #ѡ
    run_daily(trade, 'open') #
    run_daily(selled_security_list_count, 'after_close') #Ʊڼ


## Ʊɸѡʼ
def check_stocks_initialize():
    # Ƿͣ
    g.filter_paused = True
    # Ƿ
    g.filter_delisted = True
    # ǷֻST
    g.only_st = False
    # ǷST
    g.filter_st = True
    # Ʊ
    g.security_universe_index = ["000300.XSHG","000002.XSHG","399106.XSHE"]
    g.security_universe_user_securities = []
    # ҵб
    g.industry_list = ["801040","801120","801150"]
    # б
    g.concept_list = []

## Ʊɸѡʼ
def check_stocks_sort_initialize():
    # ׼ desc-asc-
    g.check_out_lists_ascending = 'desc'

## ʼ
def sell_initialize():
    # 趨Ƿbuy_listsеĹƱ
    g.sell_will_buy = False

    # ̶ֵ߰ٷֱ
    g.sell_by_amount = None
    g.sell_by_percent = None

## 볡ʼ
def buy_initialize():
    # Ƿظ
    g.filter_holded = False

    # ί
    g.order_style_str = 'by_cap_mean'
    g.order_style_value = 100

## سʼ
def risk_management_initialize():
    # Էź
    g.risk_management_signal = True

    # Եմź
    g.daily_risk_management = True

    # ֻ
    g.max_buy_value = None
    g.max_buy_amount = None


## δɹĹƱ
def sell_every_day(context):
    g.open_sell_securities = list(set(g.open_sell_securities))
    open_sell_securities = [s for s in context.portfolio.positions.keys() if s in g.open_sell_securities]
    if len(open_sell_securities)>0:
        for stock in open_sell_securities:
            order_target_value(stock, 0)
    g.open_sell_securities = [s for s in g.open_sell_securities if s in context.portfolio.positions.keys()]
    return

## 
def risk_management(context):
    ### _غɸѡ-ʼ ###
    ### _غɸѡ- ###
    return

## Ʊɸѡ
def check_stocks(context):
    if g.check_stocks_days%g.check_stocks_refresh_rate != 0:
        # һ
        g.check_stocks_days += 1
        return
    # Ʊظֵ
    g.check_out_lists = get_security_universe(context, g.security_universe_index, g.security_universe_user_securities)
    # ҵ
    g.check_out_lists = industry_filter(context, g.check_out_lists, g.industry_list)
    # 
    g.check_out_lists = concept_filter(context, g.check_out_lists, g.concept_list)
    # STƱ
    g.check_out_lists = st_filter(context, g.check_out_lists)
    # йƱ
    g.check_out_lists = delisted_filter(context, g.check_out_lists)
    # ɸѡ
    g.check_out_lists = financial_statements_filter(context, g.check_out_lists)
    # ɸѡ
    g.check_out_lists = situation_filter(context, g.check_out_lists)
    # ָɸѡ
    g.check_out_lists = technical_indicators_filter(context, g.check_out_lists)
    # ָ̬ɸѡ
    g.check_out_lists = pattern_recognition_filter(context, g.check_out_lists)
    # ɸѡ
    g.check_out_lists = other_func_filter(context, g.check_out_lists)

    # 
    input_dict = get_check_stocks_sort_input_dict()
    g.check_out_lists = check_stocks_sort(context,g.check_out_lists,input_dict,g.check_out_lists_ascending)

    # һ
    g.check_stocks_days = 1
    return

## ׺
def trade(context):
   # ʼб
    buy_lists = []

    # Ʊɸѡ
    if g.buy_trade_days%g.buy_refresh_rate == 0:
        # ȡ buy_lists б
        buy_lists = g.check_out_lists
        # STƱ
        buy_lists = st_filter(context, buy_lists)
        # ͣƹƱ
        buy_lists = paused_filter(context, buy_lists)
        # йƱ
        buy_lists = delisted_filter(context, buy_lists)
        # ͣƱ
        buy_lists = high_limit_filter(context, buy_lists)

        ### _볡ɸѡ-ʼ ###
        ### _볡ɸѡ- ###

    # 
    if g.sell_trade_days%g.sell_refresh_rate != 0:
        # һ
        g.sell_trade_days += 1
    else:
        # Ʊ
        sell(context, buy_lists)
        # һ
        g.sell_trade_days = 1


    # 
    if g.buy_trade_days%g.buy_refresh_rate != 0:
        # һ
        g.buy_trade_days += 1
    else:
        # Ʊ
        buy(context, buy_lists)
        # һ
        g.buy_trade_days = 1

## Ʊڼ
def selled_security_list_count(context):
    g.daily_risk_management = True
    if len(g.selled_security_list)>0:
        for stock in g.selled_security_list.keys():
            g.selled_security_list[stock] += 1

##################################  ѡɺȺ ##################################

## ָɸѡ
def financial_statements_filter(context, security_list):
    ### _ָɸѡ-ʼ ###
    security_list = financial_data_filter_qujian(security_list, valuation.pe_ratio, (0,25))
    security_list = financial_data_filter_qujian(security_list, valuation.pe_ratio_lyr, (0,25))
    security_list = financial_data_filter_dayu(security_list, indicator.inc_net_profit_year_on_year, 0)
    security_list = financial_data_filter_dayu(security_list, indicator.inc_revenue_annual, 0)
    security_list = financial_data_filter_dayu(security_list, indicator.inc_net_profit_annual, 0)
    security_list = financial_data_filter_dayu(security_list, indicator.inc_revenue_year_on_year, 0)
    security_list = financial_data_filter_dayu(security_list, valuation.circulating_cap, 1000)
    security_list = financial_data_filter_dayu(security_list, indicator.roe, 5)
    ### _ָɸѡ- ###

    # б
    return security_list

## ɸѡ
def situation_filter(context, security_list):
    ### _ɸѡ-ʼ ###
    ### _ɸѡ- ###

    # б
    return security_list

## ָɸѡ
def technical_indicators_filter(context, security_list):
    ### _ָɸѡ-ʼ ###
    ### _ָɸѡ- ###

    # б
    return security_list

## ָ̬ɸѡ
def pattern_recognition_filter(context, security_list):
    ### _ָ̬ɸѡ-ʼ ###
    ### _ָ̬ɸѡ- ###

    # б
    return security_list

## ʽɸѡ
def other_func_filter(context, security_list):
    ### _ʽɸѡ-ʼ ###
    ### _ʽɸѡ- ###

    # б
    return security_list

# ȡѡ input_dict
def get_check_stocks_sort_input_dict():
    input_dict = {
        }
    # ؽ
    return input_dict

##################################  ׺Ⱥ ##################################
# ׺ - 
def sell(context, buy_lists):
    # ȡ sell_lists б
    init_sl = context.portfolio.positions.keys()
    sell_lists = context.portfolio.positions.keys()

    # жǷbuy_listsеĹƱ
    if not g.sell_will_buy:
        sell_lists = [security for security in sell_lists if security not in buy_lists]

    ### _ɸѡ-ʼ ###
    ### _ɸѡ- ###

    # Ʊ
    if len(sell_lists)>0:
        for stock in sell_lists:
            sell_by_amount_or_percent_or_none(context,stock, g.sell_by_amount, g.sell_by_percent, g.open_sell_securities)

    # ȡĹƱ, 뵽 g.selled_security_list
    selled_security_list_dict(context,init_sl)

    return

# ׺ - 볡
def buy(context, buy_lists):
    # źж
    if not g.risk_management_signal:
        return

    # жϵǷ񴥷ֹ
    if not g.daily_risk_management:
        return
    # жǷظ
    buy_lists = holded_filter(context,buy_lists)

    # ȡյ buy_lists б
    Num = g.max_hold_stocknum - len(context.portfolio.positions)
    buy_lists = buy_lists[:Num]

    # Ʊ
    if len(buy_lists)>0:
        # ʽ
        result = order_style(context,buy_lists,g.max_hold_stocknum, g.order_style_str, g.order_style_value)
        for stock in buy_lists:
            if len(context.portfolio.positions) < g.max_hold_stocknum:
                # ȡʽ
                Cash = result[stock]
                # жϸֱֲ
                value = judge_security_max_proportion(context,stock,Cash,g.security_max_proportion)
                # жϵֻ
                amount = max_buy_value_or_amount(stock,value,g.max_buy_value,g.max_buy_amount)
                # µ
                order(stock, amount, MarketOrderStyle())
    return

###################################  úȺ ##################################
## 
def check_stocks_sort(context,security_list,input_dict,ascending='desc'):
    if (len(security_list) == 0) or (len(input_dict) == 0):
        return security_list
    else:
        #  key  list
        idk = list(input_dict.keys())
        # ɾ
        a = pd.DataFrame()
        for i in idk:
            b = get_sort_dataframe(security_list, i, input_dict[i])
            a = pd.concat([a,b],axis = 1)
        #  score 
        a['score'] = a.sum(1,False)
        #  score 
        if ascending == 'asc':# 
            if hasattr(a, 'sort'):
                a = a.sort(['score'],ascending = True)
            else:
                a = a.sort_values(['score'],ascending = True)
        elif ascending == 'desc':# 
            if hasattr(a, 'sort'):
                a = a.sort(['score'],ascending = False)
            else:
                a = a.sort_values(['score'],ascending = False)
        # ؽ
        return list(a.index)

## ͬһļϴN첻
def filter_n_tradeday_not_buy(security, n=0):
    try:
        if (security in g.selled_security_list.keys()) and (g.selled_security_list[security]<n):
            return False
        return True
    except:
        return True

## Ƿظ
def holded_filter(context,security_list):
    if not g.filter_holded:
        security_list = [stock for stock in security_list if stock not in context.portfolio.positions.keys()]
    # ؽ
    return security_list

## Ʊdict
def selled_security_list_dict(context,security_list):
    selled_sl = [s for s in security_list if s not in context.portfolio.positions.keys()]
    if len(selled_sl)>0:
        for stock in selled_sl:
            g.selled_security_list[stock] = 0

## ͣƹƱ
def paused_filter(context, security_list):
    if g.filter_paused:
        current_data = get_current_data()
        security_list = [stock for stock in security_list if not current_data[stock].paused]
    # ؽ
    return security_list

## йƱ
def delisted_filter(context, security_list):
    if g.filter_delisted:
        current_data = get_current_data()
        security_list = [stock for stock in security_list if not (('' in current_data[stock].name) or ('*' in current_data[stock].name))]
    # ؽ
    return security_list


## STƱ
def st_filter(context, security_list):
    if g.only_st:
        current_data = get_current_data()
        security_list = [stock for stock in security_list if current_data[stock].is_st]
    else:
        if g.filter_st:
            current_data = get_current_data()
            security_list = [stock for stock in security_list if not current_data[stock].is_st]
    # ؽ
    return security_list

# ͣƱ
def high_limit_filter(context, security_list):
    current_data = get_current_data()
    security_list = [stock for stock in security_list if not (current_data[stock].day_open >= current_data[stock].high_limit)]
    # ؽ
    return security_list

# ȡƱƱ
def get_security_universe(context, security_universe_index, security_universe_user_securities):
    temp_index = []
    for s in security_universe_index:
        if s == 'all_a_securities':
            temp_index += list(get_all_securities(['stock'], context.current_dt.date()).index)
        else:
            temp_index += get_index_stocks(s)
    for x in security_universe_user_securities:
        temp_index += x
    return  sorted(list(set(temp_index)))

# ҵ
def industry_filter(context, security_list, industry_list):
    if len(industry_list) == 0:
        # عƱб
        return security_list
    else:
        securities = []
        for s in industry_list:
            temp_securities = get_industry_stocks(s)
            securities += temp_securities
        security_list = [stock for stock in security_list if stock in securities]
        # عƱб
        return security_list

# 
def concept_filter(context, security_list, concept_list):
    if len(concept_list) == 0:
        return security_list
    else:
        securities = []
        for s in concept_list:
            temp_securities = get_concept_stocks(s)
            securities += temp_securities
        security_list = [stock for stock in security_list if stock in securities]
        # عƱб
        return security_list

#Զ庯